package dap;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class util {

	private static Map<String, Long> activeMessungen = new HashMap<String, Long>();
	private static Map<String, Long> messErgebnisse = new HashMap<String, Long>();

	public static void startMessung(String name) {
		activeMessungen.put(name.toLowerCase(), System.currentTimeMillis());
	}

	public static long stopMessung(String name) {
		name = name.toLowerCase();
		if (activeMessungen.containsKey(name)) {
			messErgebnisse.put(name, System.currentTimeMillis()
					- activeMessungen.get(name));
			return messErgebnisse.get(name);
		}
		return -1;
	}

	public static long getMessung(String name) {
		name = name.toLowerCase();
		if (name.indexOf(',') > -1) {
			long cumulate = 0;
			String[] names = name.split(",");
			for (String _name : names)
				cumulate += getMessung(_name);
			return cumulate;
		} else {
			if (activeMessungen.containsKey(name)) {
				return messErgebnisse.get(name);
			}
		}
		return -1;
	}

	public static int min (int... b) {
		if (b.length > 0) {
			int smallest;
			smallest = b[0];
			for(int i = 1; i < b.length; i++) 
				if (b[i] < smallest) 
					smallest = b[i];
			return smallest;
		} else {
			throw new IllegalArgumentException("Keine Argumente übergeben.");
		}
	}

	public static int max (int... b) {
		if (b.length > 0) {
			int biggest;
			biggest = b[0];
			for(int i = 1; i < b.length; i++) 
				if (b[i] > biggest) 
					biggest = b[i];
			return biggest;
		} else {
			throw new IllegalArgumentException("Keine Argumente übergeben.");
		}
	}
	
	/**
	 * 
	 * @param n Anzahl der Zeichen im Zielstring
	 * @param r Randomgenerator java.util.Random
	 * @return
	 */
	public static String randStr(int n, Random r) {
		String alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
		StringBuilder res = new StringBuilder(n);
		while (--n >= 0)
			res.append(alphabet.charAt(r.nextInt(alphabet.length())));
		return res.toString();
	}

	public static int indexOfMax(Object a[]) {
		return (a.getClass().equals(Number.class)) ? indexOfMax((Number[]) a,
				0, a.length - 1) : indexOfMax((String[]) a, 0, a.length - 1);
	}

	public static int indexOfMax(Number a[], int l, int r) {
		if (r - l == 1)
			return l;

		int m = (l + r) / 2;
		int u = indexOfMax(a, l, m);
		int v = indexOfMax(a, m, r);

		return a[u].doubleValue() > a[v].doubleValue() ? u : v;
	}

	public static int indexOfMax(String a[], int l, int r) {
		if (r - l == 1)
			return l;

		int m = (l + r) / 2;
		int u = indexOfMax(a, l, m);
		int v = indexOfMax(a, m, r);

		return a[u].compareTo(a[v]) >= 0 ? u : v;
	}

	/**
	 * Gibt ein int-Array auf der Konsole aus
	 * 
	 * @param array
	 *            das Array, welches ausgegeben werden soll
	 */
	public static void printArray(int[] array) {
		int idxl = String.valueOf(array.length).length(), odd = (array.length % 2 == 0 ? 0
				: 1), dest = array.length / 2 + odd;

		for (int j, i = 0; i < dest; i++) {
			j = dest + i;
			System.out.format("%" + idxl + "d => %11d", i, array[i]);
			if (j < array.length)
				System.out.format("  %" + idxl + "d => %11d\n", j, array[j]);
		}

		System.out.println();
	}

	/**
	 * Gibt ein int-Array auf der Konsole aus
	 * 
	 * @param array
	 *            das Array, welches ausgegeben werden soll
	 * @param array
	 *            das Array, das als Key-Array dienen soll
	 */
	public static void printArray(int[] array, String[] keys, boolean repeating) {
		int idxl = String.valueOf(keys[indexOfMax(keys)]).length(), odd = (array.length % 2 == 0 ? 0
				: 1), dest = array.length / 2 + odd;

		String a, b;

		for (int j, i = 0; i < dest; i++) {
			j = dest + i;
			if (repeating) {
				a = keys[i % keys.length];
				b = keys[j % keys.length];
			} else {
				a = i < keys.length ? keys[i] : String.valueOf(i);
				b = j < keys.length ? keys[j] : String.valueOf(j);
			}

			System.out.format("%" + idxl + "s => %11d", a, array[i]);
			if (j < array.length)
				System.out.format("  %" + idxl + "s => %11d\n", b, array[j]);
		}

		System.out.println();
	}

	/**
	 * Mittels arrCreate wird ein Integer-Array angelegt, das es über die
	 * angegebene Methode "fill" mit "size" Werten füllt
	 */
	public static int[] arrCreate(int size, String fill) {
		int[] array = new int[size]; // Integer Array mit Größe "size"
										// initialisieren

		if (fill == "auf") { // Falls die Methode "auf" ist,
			for (int i = 0; i < size; i++)
				// Wird ein Array mit aufsteigenden (entsprechend bereits
				// sortierten Werten) generiert
				array[i] = i + 1;
		} else if (fill == "ab") { // Falls die Methode "ab" ist,
			for (int i = 0; i < size; i++)
				// Wird ein Array mit absteigenden Werten generiert
				array[i] = size - i;
		} else {
			// Wird "rand" oder etwas anderes übergeben, werden Zufallswerte
			// eingefügt
			java.util.Random numberGenerator = new java.util.Random(); // Randomgenerator
																		// instanziieren
			for (int i = 0; i < size; i++) { // array füllen
				array[i] = numberGenerator.nextInt(); // mit der nächstbesten
														// Zufalls-Integer-Zahl
			}
		}

		return array; // Rückgabe des generierten Arrays
	}

	public static String[] toStringArray(int[] array) {
		String[] _array = new String[array.length];
		for (int i = 0; i < array.length; i++)
			_array[i] = String.valueOf(array[i]);

		return _array;
	}

}
